// POST https://lfs-server.com/objects/batch
// Accept: application/vnd.git-lfs+json
// Content-Type: application/vnd.git-lfs+json
// Authorization: Basic ... (if needed)
{
  "operation": "upload", // ダウンロード or アップロードどちらの情報がほしいか
  "objects": [ // ファイルの詳細
    {
      "oid": "12345678", // LFSファイルの一意なID
      "size": 123 // LFSファイルのサイズ
    }
  ]
}

// HTTP/1.1 200 Ok
// Content-Type: application/vnd.git-lfs+json
{
  "transfer": "basic", // なくてもいい
  "objects": [
    {
      "oid": "1111111", // リクエストで来たoidをそのまま返せばいい
      "size": 123, // リクエストできたサイズをそのまま返せばいい
      "authenticated": true, // 認証済みということにする
      "actions": {
				// ダウンロードについての情報であれば "download"
				// アップロードについての情報であれば "upload" とする
        "download": {  
          "href": "https://some-download.com", // 格納先URL
					// クライアントからストレージへの通信のheaderに何か付与したい場合書く。
					// なくてもいい
          "header": { 
            "Key": "value" 
          },
					// 以下はどちらかでOK。アクセス可能期間
					"expires_in" : 86400,
          "expires_at": "2016-11-10T15:29:07Z"
        }
      }
    }
  ],
	// なくていい。デフォルトsha256
  "hash_algo": "sha256"
}

gcloud functions deploy [任意Funcion名] --entry-point [エントリポイント] --runtime dotnet6 --trigger-http --allow-unauthenticated --source .

# openapi2-functions.yaml
swagger: '2.0'
info:
  title: gcs-lfs-server GCS
  description: Sample API on API Gateway with a Google Cloud Functions backend
  version: 1.0.0
schemes:
  - https
produces:
  - application/json
paths:
  /[任意名]/objects/batch: # ※1
    post:
      summary: git lfs upload and download proxy
      operationId: [任意名]
			# 実行するFunctionを定義
      x-google-backend:
        address: https://[リージョン]-[プロジェクトID].cloudfunctions.net/[実行するFunction名]
      responses:
        '200':
          description: A successful response
          schema:
            type: string

using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using Google.Cloud.Storage.V1;
using System.Threading.Tasks;
using System;
using System.Net.Http;
using System.IO;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http.Extensions;
using System.Xml.Linq;
using System.Linq;

namespace GDriveLFS
{
    /// <summary>
    /// 署名付きURL
    /// </summary>
    public class V4SignedUrlGenerator
    {
        public string GenerateV4SignedReadUrl(
            string bucketName,
            string objectName,
            string credentialFilePath)
        {
            UrlSigner urlSigner = UrlSigner.FromServiceAccountPath(credentialFilePath);
            string url = urlSigner.Sign(bucketName, objectName, TimeSpan.FromHours(1), HttpMethod.Get);

            return url;
        }

        public string GenerateV4UploadSignedUrl(
            string bucketName,
            string objectName,
            string credentialFilePath)
        {
            UrlSigner urlSigner = UrlSigner.FromServiceAccountPath(credentialFilePath);

            var options = UrlSigner.Options.FromDuration(TimeSpan.FromHours(1));

            var template = UrlSigner.RequestTemplate
                .FromBucket(bucketName)
                .WithObjectName(objectName)
                .WithHttpMethod(HttpMethod.Put);

            string url = urlSigner.Sign(template, options);
            return url;
        }
    }

    public class GCSStorageController
    {
        public const string BacketName = "[gcsのバケット名]";
        public const string CredentialFileName = "[アカウントキー.jsonファイル名]"; // credential file (with private keys)

        private V4SignedUrlGenerator _urlGenerator = new V4SignedUrlGenerator();
        private string _credentialFilePath;

				public string Path => $"{Directory.GetCurrentDirectory()}/{CredentialFileName}";

        public void Setup()
        {
            while (!File.Exists(Path))
            {
                var path = Directory.GetParent(Directory.GetCurrentDirectory()).FullName;
                Directory.SetCurrentDirectory(path);
            }

            _credentialFilePath = Path;
        }

        public string GetDownloadURL(string objectName)
        {
            if (string.IsNullOrEmpty(_credentialFilePath)) return string.Empty;

            var result = _urlGenerator.GenerateV4SignedReadUrl(BacketName, objectName, _credentialFilePath);
            return result;
        }

        public string GetUploadURL(string objectName)
        {
            if (string.IsNullOrEmpty(_credentialFilePath)) return string.Empty;

            var result = _urlGenerator.GenerateV4UploadSignedUrl(BacketName, objectName, _credentialFilePath);
            return result;
        }
    }


    public class RequestBody
    {
        public class Object
        {
            public string oid { get; set; }
            public int size { get; set; }
        }

        public string operation { get; set; }
        public string[] transfers { get; set; }
        public Object[] objects { get; set; }
        public string hash_algo { get; set; }
    }


    public class ResponseBody
    {
        public class URL
        {
            public string href { get; set; }
            public int expires_in { get; set; }

            public static URL CreateAtDownload(string oid) =>
                new URL { href = Function.StorageController.GetDownloadURL(oid), expires_in = 86400 };

            public static URL CreateAtUpload(string oid) =>
                new URL { href = Function.StorageController.GetUploadURL(oid), expires_in = 86400 };

            public static URL CreateAtEmpty() =>
                new URL { href = "" };
        }

        public class Action
        {
            public URL upload { get; set; }
            public URL download { get; set; }

            public static Action CreateAtUpload(string oid) =>
                new Action() { upload = URL.CreateAtUpload(oid), download = URL.CreateAtEmpty() };

            public static Action CreateAtDownload(string oid) =>
                new Action() { download = URL.CreateAtDownload(oid), upload = URL.CreateAtEmpty() };
        }

        public class Object
        {
            public string oid { get; set; }
            public int size { get; set; }
            public bool authenticated { get; set; } = true;
            public Action actions { get; set; }

            public static Object CreateAtUpload(string oid, int size) =>
                new Object { oid = oid, size = size, actions = Action.CreateAtUpload(oid) };

            public static Object CreateAtDownload(string oid, int size) =>
                new Object { oid = oid, size = size, actions = Action.CreateAtDownload(oid) };
        }

        public string transfer { get; set; } = "basic";
        public Object[] objects { get; set; }


        public static ResponseBody CreateAtUpload(RequestBody.Object[] objects) =>
            new ResponseBody { objects = objects.Select(x => Object.CreateAtUpload(x.oid, x.size)).ToArray() };

        public static ResponseBody CreateAtDownload(RequestBody.Object[] objects) =>
            new ResponseBody { objects = objects.Select(x => Object.CreateAtDownload(x.oid, x.size)).ToArray() };
    }

    public class Function : IHttpFunction
    {
        public static GCSStorageController StorageController;
        private readonly ILogger _logger;

        public Function(ILogger<Function> logger) =>
            _logger = logger;

        public async Task HandleAsync(HttpContext context)
        {
            var request = context.Request;

            // If there's a body, parse it as JSON and check for "message" field.
            using TextReader reader = new StreamReader(request.Body);
            string text = await reader.ReadToEndAsync();

            if (text.Length <= 0)
            {
                _logger.LogError("RequestBody Not found");
                return;
            }

            _logger.LogInformation($"*** Request: {text}");

            try
            {
                var requestBody = JsonSerializer.Deserialize<RequestBody>(text);

                StorageController = new GCSStorageController();
								StorageController.Setup();

                var response = default(ResponseBody);

                switch (requestBody.operation)
                {
                    case "upload":
                        response = ResponseBody.CreateAtUpload(requestBody.objects);
                        break;

                    case "download":
                        response = ResponseBody.CreateAtDownload(requestBody.objects);
                        break;

                    default: // verify
                        return;
                }

                var responseBody = JsonSerializer.Serialize<ResponseBody>(response);

                _logger.LogInformation($"*** Response: {responseBody}");

                context.Response.ContentType = "application/vnd.git-lfs+json";
                await context.Response.WriteAsJsonAsync<ResponseBody>(response);
            }
            catch (JsonException parseException)
            {
                _logger.LogError(parseException, "Error parsing JSON request");
            }
        }
    }
}

*.jpg filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text